//// Project: XnaPong, File: PongGame.cs
//// Namespace: XnaPong, Class: PongGame
//// Path: C:\code\XnaBook\XnaPong, Author: Abi
//// Code lines: 16, Size of file: 298 Bytes
//// Creation date: 18.11.2006 03:56
//// Last modified: 19.11.2006 13:21
//// Generated with Commenter by abi.exDream.com

//#region Using directives
//using System;
//using System.Collections.Generic;
//using Microsoft.Xna.Framework;
//using Microsoft.Xna.Framework.Audio;
//using Microsoft.Xna.Framework.Content;
//using Microsoft.Xna.Framework.Graphics;
//using Microsoft.Xna.Framework.Input;
//using Microsoft.Xna.Framework.Storage;
//#endregion

//namespace XnaPong
//{
//    /// <summary>
//    /// This is the main type for your game
//    /// </summary>
//    public class PongGame : Microsoft.Xna.Framework.Game
//    {
//        #region Constants
//        /// <summary>
//        /// Rectangles for our graphics, tested with the unit tests below.
//        /// </summary>
//        static readonly Rectangle
//            XnaPongLogoRect = new Rectangle(0, 0, 512, 110),
//            MenuSingleplayerRect = new Rectangle(0, 110, 512, 38),
//            MenuMultiplayerRect = new Rectangle(0, 148, 512, 38),
//            MenuExitRect = new Rectangle(0, 185, 512, 38),
//            GameLivesRect = new Rectangle(0, 222, 100, 34),
//            GameRedWonRect = new Rectangle(151, 222, 155, 34),
//            GameBlueWonRect = new Rectangle(338, 222, 165, 34),
//            GameRedPaddleRect = new Rectangle(23, 0, 22, 92),
//            GameBluePaddleRect = new Rectangle(0, 0, 22, 92),
//            GameBallRect = new Rectangle(1, 94, 33, 33),
//            GameSmallBallRect = new Rectangle(37, 108, 19, 19);

//        /// <summary>
//        /// Ball speed multiplicator, this is how much screen space the ball will
//        /// travel each second.
//        /// </summary>
//        const float BallSpeedMultiplicator = 0.5f;

//        /// <summary>
//        /// Computer paddle speed. If the ball moves faster up or down than this,
//        /// the computer paddle can't keep up and finally we will win.
//        /// </summary>
//        const float ComputerPaddleSpeed = 0.5f;//25f;

//        /// <summary>
//        /// Game modes
//        /// </summary>
//        enum GameMode
//        {
//            Menu,
//            Game,
//            GameOver,
//        } // enum GameMode
//        #endregion

//        #region Variables
//        GraphicsDeviceManager graphics;
//        ContentManager content;
//        Texture2D backgroundTexture, menuTexture, gameTexture;
//        AudioEngine audioEngine;
//        WaveBank waveBank;
//        SoundBank soundBank;

//        /// <summary>
//        /// Resolution of our game.
//        /// </summary>
//        int width, height;

//        /// <summary>
//        /// Current paddle positions, 0 means top, 1 means bottom.
//        /// </summary>
//        float leftPaddlePosition = 0.5f,
//            rightPaddlePosition = 0.5f;

//        /// <summary>
//        /// Current ball position, again from 0 to 1, 0 is left and top,
//        /// 1 is bottom and right.
//        /// </summary>
//        Vector2 ballPosition = new Vector2(0.5f, 0.5f);
//        /// <summary>
//        /// Ball speed vector, randomized for every new ball.
//        /// Will be set to Zero if we are in menu or game is over.
//        /// </summary>
//        Vector2 ballSpeedVector = new Vector2(0, 0);//1);

//        /// <summary>
//        /// Life for left and right players. If one player has 0 lives left,
//        /// the other one wins.
//        /// </summary>
//        int leftPlayerLives = 3,
//            rightPlayerLives = 3;

//        /// <summary>
//        /// Are we playing a multiplayer game? If this is false, the computer
//        /// controls the left paddle.
//        /// </summary>
//        bool multiplayer = false;

//        /// <summary>
//        /// Game mode we are currently in. Very simple game flow.
//        /// </summary>
//        GameMode gameMode = GameMode.Menu;

//        /// <summary>
//        /// Currently selected menu item.
//        /// </summary>
//        int currentMenuItem = 0;
//        #endregion

//        #region Constructor
//        /// <summary>
//        /// Create pong game
//        /// </summary>
//        public PongGame()
//        {
//            graphics = new GraphicsDeviceManager(this);
//            content = new ContentManager(Services);
//        } // PongGame()

//        /// <summary>
//        /// Allows the game to perform any initialization it needs to before starting to run.
//        /// This is where it can query for any required services and load any non-graphic
//        /// related content.  Calling base.Initialize will enumerate through any components
//        /// and initialize them as well.
//        /// </summary>
//        protected override void Initialize()
//        {
//            // Remember resolution
//            width = graphics.GraphicsDevice.Viewport.Width;
//            height = graphics.GraphicsDevice.Viewport.Height;

//            base.Initialize();
//        } // Initialize()

//        /// <summary>
//        /// Load all graphics content (just our background texture).
//        /// Use this method to make sure a device reset event is handled correctly.
//        /// </summary>
//        /// <param name="loadAllContent">Load everything?</param>
//        protected override void LoadGraphicsContent(bool loadAllContent)
//        {
//            if (loadAllContent)
//            {
//                // Create sprite batch
//                spriteBatch = new SpriteBatch(graphics.GraphicsDevice);

//                // Load all our content
//                backgroundTexture = content.Load<Texture2D>("SpaceBackground");
//                menuTexture = content.Load<Texture2D>("PongMenu");
//                gameTexture = content.Load<Texture2D>("PongGame");
//                audioEngine = new AudioEngine("PongSound.xgs");
//                waveBank = new WaveBank(audioEngine, "Wave Bank.xwb");
//                if (waveBank != null)
//                    soundBank = new SoundBank(audioEngine, "Sound Bank.xsb");
//            } // if
//            base.LoadGraphicsContent(loadAllContent);
//        } // LoadGraphicsContent(loadAllContent)

//        /// <summary>
//        /// Unload graphic content if the device gets lost.
//        /// </summary>
//        /// <param name="unloadAllContent">Unload everything?</param>
//        protected override void UnloadGraphicsContent(bool unloadAllContent)
//        {
//            if (unloadAllContent == true)
//                content.Unload();

//            base.UnloadGraphicsContent(unloadAllContent);
//        } // UnloadGraphicsContent(loadAllContent)
//        #endregion

//        #region Start and stop ball
//        /// <summary>
//        /// Start new ball at the beginning of each game and when a ball is lost.
//        /// </summary>
//        public void StartNewBall()
//        {
//            ballPosition = new Vector2(0.5f, 0.5f);
//            Random rnd = new Random((int)DateTime.Now.Ticks);
//            int direction = rnd.Next(4);
//            ballSpeedVector =
//                direction == 0 ? new Vector2(1, 0.8f) :
//                direction == 1 ? new Vector2(1, -0.8f) :
//                direction == 2 ? new Vector2(-1, 0.8f) :
//                new Vector2(-1, -0.8f);
//        } // StartNewBall()

//        /// <summary>
//        /// Stop ball for menu and when game is over.
//        /// </summary>
//        public void StopBall()
//        {
//            ballSpeedVector = new Vector2(0, 0);
//        } // StopBall
//        #endregion

//        #region Update
//        /// <summary>
//        /// Game pad and keyboard states for full 2 player support.
//        /// </summary>
//        GamePadState gamePad, gamePad2;
//        KeyboardState keyboard;

//        /// <summary>
//        /// Remember up, down, start and back buttons for the menu.
//        /// </summary>
//        bool remUpPressed = false,
//            remDownPressed = false,
//            remSpaceOrStartPressed = false,
//            remEscOrBackPressed = false;

//        /// <summary>
//        /// Store up/down states and include thumbstick to control paddles.
//        /// </summary>
//        bool gamePadUp = false,
//            gamePadDown = false,
//            gamePad2Up = false,
//            gamePad2Down = false;

//        /// <summary>
//        /// Allows the game to run logic such as updating the world,
//        /// checking for collisions, gathering input and playing audio.
//        /// </summary>
//        /// <param name="gameTime">Provides a snapshot of timing values.</param>
//        protected override void Update(GameTime gameTime)
//        {
//            // Remember last keyboard and gamepad states for the menu
//            remUpPressed =
//                gamePad.DPad.Up == ButtonState.Pressed ||
//                gamePad.ThumbSticks.Left.Y > 0.5f ||
//                keyboard.IsKeyDown(Keys.Up);
//            remDownPressed =
//                gamePad.DPad.Down == ButtonState.Pressed ||
//                gamePad.ThumbSticks.Left.Y < -0.5f ||
//                keyboard.IsKeyDown(Keys.Down);
//            remSpaceOrStartPressed =
//                gamePad.Buttons.Start == ButtonState.Pressed ||
//                gamePad.Buttons.A == ButtonState.Pressed ||
//                keyboard.IsKeyDown(Keys.LeftControl) ||
//                keyboard.IsKeyDown(Keys.RightControl) ||
//                keyboard.IsKeyDown(Keys.Space) ||
//                keyboard.IsKeyDown(Keys.Enter);
//            remEscOrBackPressed =
//                gamePad.Buttons.Back == ButtonState.Pressed ||
//                keyboard.IsKeyDown(Keys.Escape);

//            // Get current gamepad and keyboard states
//            gamePad = GamePad.GetState(PlayerIndex.One);
//            gamePad2 = GamePad.GetState(PlayerIndex.Two);
//            keyboard = Keyboard.GetState();

//            gamePadUp = gamePad.DPad.Up == ButtonState.Pressed ||
//                gamePad.ThumbSticks.Left.Y > 0.5f;
//            gamePadDown = gamePad.DPad.Down == ButtonState.Pressed ||
//                gamePad.ThumbSticks.Left.Y < -0.5f;
//            gamePad2Up = gamePad2.DPad.Up == ButtonState.Pressed ||
//                gamePad2.ThumbSticks.Left.Y > 0.5f;
//            gamePad2Down = gamePad2.DPad.Down == ButtonState.Pressed ||
//                gamePad2.ThumbSticks.Left.Y < -0.5f;

//            // Move half way across the screen each second
//            float moveFactorPerSecond = 0.5f *
//                (float)gameTime.ElapsedRealTime.TotalMilliseconds / 1000.0f;

//            // Move up and down if we press the cursor or gamepad keys.
//            if (gamePadUp ||
//                keyboard.IsKeyDown(Keys.Up))
//                rightPaddlePosition -= moveFactorPerSecond;
//            if (gamePadDown ||
//                keyboard.IsKeyDown(Keys.Down))
//                rightPaddlePosition += moveFactorPerSecond;

//            // Second player is either controlled by player 2 or by the computer
//            if (multiplayer)
//            {
//                // Move up and down if we press the cursor or gamepad keys.
//                if (gamePad2Up ||
//                    keyboard.IsKeyDown(Keys.W))
//                    leftPaddlePosition -= moveFactorPerSecond;
//                if (gamePad2Down ||
//                    keyboard.IsKeyDown(Keys.S) ||
//                    keyboard.IsKeyDown(Keys.O))
//                    leftPaddlePosition += moveFactorPerSecond;
//            } // if
//            else
//            {
//                // Just let the computer follow the ball position
//                float computerChange = ComputerPaddleSpeed * moveFactorPerSecond;
//                if (leftPaddlePosition > ballPosition.Y + computerChange)
//                    leftPaddlePosition -= computerChange;
//                else if (leftPaddlePosition < ballPosition.Y - computerChange)
//                    leftPaddlePosition += computerChange;
//            } // else

//            // Make sure paddles stay between 0 and 1
//            if (leftPaddlePosition < 0)
//                leftPaddlePosition = 0;
//            if (leftPaddlePosition > 1)
//                leftPaddlePosition = 1;
//            if (rightPaddlePosition < 0)
//                rightPaddlePosition = 0;
//            if (rightPaddlePosition > 1)
//                rightPaddlePosition = 1;

//            // Ball is stopped and we are in the game? Then start it again.
//            if (ballSpeedVector.LengthSquared() == 0 &&
//                gameMode == GameMode.Game)
//                StartNewBall();

//            // Check top and bottom screen border
//            if (ballPosition.Y < 0 ||
//                ballPosition.Y > 1)
//            {
//                ballSpeedVector.Y = -ballSpeedVector.Y;
//                soundBank.PlayCue("PongBallHit");
//            } // if

//            // Check for collisions with the paddles
//            // Construct bounding boxes to use the intersection helper method.
//            Vector2 ballSize = new Vector2(
//                GameBallRect.Width / 1024.0f, GameBallRect.Height / 768.0f);
//            BoundingBox ballBox = new BoundingBox(
//                new Vector3(ballPosition.X - ballSize.X / 2, ballPosition.Y - ballSize.Y / 2, 0),
//                new Vector3(ballPosition.X + ballSize.X / 2, ballPosition.Y + ballSize.Y / 2, 0));
//            Vector2 paddleSize = new Vector2(
//                GameRedPaddleRect.Width / 1024.0f, GameRedPaddleRect.Height / 768.0f);
//            BoundingBox leftPaddleBox = new BoundingBox(
//                new Vector3(-paddleSize.X / 2, leftPaddlePosition - paddleSize.Y / 2, 0),
//                new Vector3(+paddleSize.X / 2, leftPaddlePosition + paddleSize.Y / 2, 0));
//            BoundingBox rightPaddleBox = new BoundingBox(
//                new Vector3(1 - paddleSize.X / 2, rightPaddlePosition - paddleSize.Y / 2, 0),
//                new Vector3(1 + paddleSize.X / 2, rightPaddlePosition + paddleSize.Y / 2, 0));

//            // Ball hit left paddle?
//            if (ballBox.Intersects(leftPaddleBox))
//            {
//                // Bounce of the paddle (always make positive)
//                ballSpeedVector.X = Math.Abs(ballSpeedVector.X);
//                // Increase speed a little
//                ballSpeedVector *= 1.05f;
//                // Did we hit the edges of the paddle?
//                if (ballBox.Intersects(new BoundingBox(
//                    new Vector3(leftPaddleBox.Min.X - 0.01f, leftPaddleBox.Min.Y - 0.01f, 0),
//                    new Vector3(leftPaddleBox.Min.X + 0.01f, leftPaddleBox.Min.Y + 0.01f, 0))))
//                    // Bounce of at a more difficult angle for the other player
//                    ballSpeedVector.Y = -2;
//                else if (ballBox.Intersects(new BoundingBox(
//                    new Vector3(leftPaddleBox.Min.X - 0.01f, leftPaddleBox.Max.Y - 0.01f, 0),
//                    new Vector3(leftPaddleBox.Min.X + 0.01f, leftPaddleBox.Max.Y + 0.01f, 0))))
//                    // Bounce of at a more difficult angle for the other player
//                    ballSpeedVector.Y = +2;
//                // Play sound
//                soundBank.PlayCue("PongBallHit");
//            } // if

//            // Ball hit right paddle?
//            if (ballBox.Intersects(rightPaddleBox))
//            {
//                // Bounce of the paddle (always make negative)
//                ballSpeedVector.X = -Math.Abs(ballSpeedVector.X);
//                // Increase speed a little
//                ballSpeedVector *= 1.05f;
//                // Did we hit the edges of the paddle?
//                if (ballBox.Intersects(new BoundingBox(
//                    new Vector3(rightPaddleBox.Min.X - 0.01f, rightPaddleBox.Min.Y - 0.01f, 0),
//                    new Vector3(rightPaddleBox.Min.X + 0.01f, rightPaddleBox.Min.Y + 0.01f, 0))))
//                    // Bounce of at a more difficult angle for the other player
//                    ballSpeedVector.Y = -2;
//                else if (ballBox.Intersects(new BoundingBox(
//                    new Vector3(rightPaddleBox.Min.X - 0.01f, rightPaddleBox.Max.Y - 0.01f, 0),
//                    new Vector3(rightPaddleBox.Min.X + 0.01f, rightPaddleBox.Max.Y + 0.01f, 0))))
//                    // Bounce of at a more difficult angle for the other player
//                    ballSpeedVector.Y = +2;

//                // Play sound
//                soundBank.PlayCue("PongBallHit");
//            } // if

//            // Update ball position and bounce off the borders
//            ballPosition += ballSpeedVector *
//                moveFactorPerSecond * BallSpeedMultiplicator;

//            // Ball lost?
//            if (ballPosition.X < -0.065f)
//            {
//                // Play sound
//                soundBank.PlayCue("PongBallLost");
//                // Reduce number of lives
//                leftPlayerLives--;
//                // Start new ball
//                StartNewBall();
//            } // if
//            else if (ballPosition.X > 1.065f)
//            {
//                // Play sound
//                soundBank.PlayCue("PongBallLost");
//                // Reduce number of lives
//                rightPlayerLives--;
//                // Start new ball
//                StartNewBall();
//            } // if

//            // If either player has no more lives, the other one has won!
//            if (gameMode == GameMode.Game &&
//                (leftPlayerLives == 0 ||
//                rightPlayerLives == 0))
//            {
//                gameMode = GameMode.GameOver;
//                StopBall();
//            } // if

//            base.Update(gameTime);
//        } // Update(gameTime)
//        #endregion

//        #region Sprite handling
//        class SpriteToRender
//        {
//            public Texture2D texture;
//            public Rectangle rect;
//            public Rectangle? sourceRect;
//            public Color color;

//            public SpriteToRender(Texture2D setTexture, Rectangle setRect,
//                Rectangle? setSourceRect, Color setColor)
//            {
//                texture = setTexture;
//                rect = setRect;
//                sourceRect = setSourceRect;
//                color = setColor;
//            } // SpriteToRender(setTexture, setRect, setColor)
//        } // SpriteToRender

//        List<SpriteToRender> sprites = new List<SpriteToRender>();
//        SpriteBatch spriteBatch = null;

//        public void RenderSprite(Texture2D texture, Rectangle rect, Rectangle? sourceRect,
//            Color color)
//        {
//            sprites.Add(new SpriteToRender(texture, rect, sourceRect, color));
//        } // RenderSprite(texture, rect, sourceRect, color)

//        public void RenderSprite(Texture2D texture, Rectangle rect, Rectangle? sourceRect)
//        {
//            RenderSprite(texture, rect, sourceRect, Color.White);
//        } // RenderSprite(texture, rect, sourceRect)

//        public void RenderSprite(Texture2D texture, int x, int y, Rectangle? sourceRect,
//            Color color)
//        {
//            RenderSprite(texture,
//                new Rectangle(x, y, sourceRect.Value.Width, sourceRect.Value.Height),
//                sourceRect, color);
//        } // RenderSprite(texture, rect, sourceRect)

//        public void RenderSprite(Texture2D texture, int x, int y, Rectangle? sourceRect)
//        {
//            RenderSprite(texture,
//                new Rectangle(x, y, sourceRect.Value.Width, sourceRect.Value.Height),
//                sourceRect, Color.White);
//        } // RenderSprite(texture, rect, sourceRect)

//        public void RenderSprite(Texture2D texture, Rectangle rect, Color color)
//        {
//            RenderSprite(texture, rect, null, color);
//        } // RenderSprite(texture, rect, color)

//        public void RenderSprite(Texture2D texture, Rectangle rect)
//        {
//            RenderSprite(texture, rect, null, Color.White);
//        } // RenderSprite(texture, rect)

//        public void RenderSprite(Texture2D texture)
//        {
//            RenderSprite(texture, new Rectangle(0, 0, 1024, 768), null, Color.White);
//        } // RenderSprite(texture)

//        public void DrawSprites()
//        {
//            // No need to render if we got no sprites this frame
//            if (sprites.Count == 0)
//                return;

//            // Start rendering sprites
//            spriteBatch.Begin(SpriteBlendMode.AlphaBlend,
//                SpriteSortMode.BackToFront, SaveStateMode.None);

//            // Render all sprites
//            foreach (SpriteToRender sprite in sprites)
//                spriteBatch.Draw(sprite.texture,
//                    // Rescale to fit resolution
//                    new Rectangle(
//                    sprite.rect.X * width / 1024,
//                    sprite.rect.Y * height / 768,
//                    sprite.rect.Width * width / 1024,
//                    sprite.rect.Height * height / 768),
//                    sprite.sourceRect, sprite.color);

//            // We are done, draw everything on screen with help of the end method.
//            spriteBatch.End();

//            // Kill list of remembered sprites
//            sprites.Clear();
//        } // DrawSprites()
//        #endregion

//        #region Render ball and paddles
//        public void RenderBall()
//        {
//            RenderSprite(gameTexture,
//                (int)((0.05f + 0.9f * ballPosition.X) * 1024) - GameBallRect.Width / 2,
//                (int)((0.02f + 0.96f * ballPosition.Y) * 768) - GameBallRect.Height / 2,
//                GameBallRect);
//        } // RenderBall()

//        public void RenderPaddles()
//        {
//            RenderSprite(gameTexture,
//                (int)(0.05f * 1024) - GameRedPaddleRect.Width / 2,
//                (int)((0.06f + 0.88f * leftPaddlePosition) * 768) - GameRedPaddleRect.Height / 2,
//                GameRedPaddleRect);
//            RenderSprite(gameTexture,
//                (int)(0.95f * 1024) - GameBluePaddleRect.Width / 2,
//                (int)((0.06f + 0.88f * rightPaddlePosition) * 768) - GameBluePaddleRect.Height / 2,
//                GameBluePaddleRect);
//        } // RenderPaddle(leftPaddle)

//        public void ShowLives()
//        {
//            // Support for both Windows monitors and TV screens on the Xbox 360!
//            int xPos = 2;
//            int yPos = 2;
//#if XBOX360
//            xPos += Window.ClientBounds.Width / 24;
//            yPos += Window.ClientBounds.Height / 24;
//#endif
//            // Left players lives
//            RenderSprite(menuTexture, xPos, yPos, GameLivesRect);
//            for (int num = 0; num < leftPlayerLives; num++)
//                RenderSprite(gameTexture,
//                    xPos + GameLivesRect.Width + GameSmallBallRect.Width * num - 2,
//                    yPos + 7,
//                    GameSmallBallRect);

//            // Right players lives
//            int rightX = 1024 - GameLivesRect.Width - GameSmallBallRect.Width * 3 - xPos - 2;
//            RenderSprite(menuTexture, rightX, yPos, GameLivesRect);
//            for (int num = 0; num < rightPlayerLives; num++)
//                RenderSprite(gameTexture,
//                    rightX + GameLivesRect.Width + GameSmallBallRect.Width * num - 2,
//                    yPos + 7,
//                    GameSmallBallRect);
//        } // ShowLives()
//        #endregion

//        #region Draw
//        /// <summary>
//        /// This is called when the game should draw itself.
//        /// </summary>
//        /// <param name="gameTime">Provides a snapshot of timing values.</param>
//        protected override void Draw(GameTime gameTime)
//        {
//            // Clear background
//            graphics.GraphicsDevice.Clear(Color.Black);

//            // Draw background texture in a seperate pass, else it gets messed up with
//            // our other sprites, the ordering does not really work great.
//            spriteBatch.Begin();
//            spriteBatch.Draw(backgroundTexture,
//                new Rectangle(0, 0, width, height),
//                Color.LightGray);
//            spriteBatch.End();

//            // Show screen depending on our current screen mode
//            if (gameMode == GameMode.Menu)
//            {
//                // Show menu
//                RenderSprite(menuTexture,
//                    512 - XnaPongLogoRect.Width / 2, 150, XnaPongLogoRect);
//                RenderSprite(menuTexture,
//                    512 - MenuSingleplayerRect.Width / 2, 300, MenuSingleplayerRect,
//                    currentMenuItem == 0 ? Color.Orange : Color.White);
//                RenderSprite(menuTexture,
//                    512 - MenuMultiplayerRect.Width / 2, 350, MenuMultiplayerRect,
//                    currentMenuItem == 1 ? Color.Orange : Color.White);
//                RenderSprite(menuTexture,
//                    512 - MenuExitRect.Width / 2, 400, MenuExitRect,
//                    currentMenuItem == 2 ? Color.Orange : Color.White);

//                // Note: Usually input should be handled in Update, but I really think
//                // it is better to have to closely together with the UI code here!
//                if ((keyboard.IsKeyDown(Keys.Down) ||
//                    gamePadDown) &&
//                    remDownPressed == false)
//                {
//                    currentMenuItem = (currentMenuItem + 1) % 3;
//                    soundBank.PlayCue("PongBallHit");
//                } // else if
//                else if ((keyboard.IsKeyDown(Keys.Up) ||
//                    gamePadUp) &&
//                    remUpPressed == false)
//                {
//                    currentMenuItem = (currentMenuItem + 2) % 3;
//                    soundBank.PlayCue("PongBallHit");
//                } // else if
//                else if ((keyboard.IsKeyDown(Keys.Space) ||
//                    keyboard.IsKeyDown(Keys.LeftControl) ||
//                    keyboard.IsKeyDown(Keys.RightControl) ||
//                    keyboard.IsKeyDown(Keys.Enter) ||
//                    gamePad.Buttons.A == ButtonState.Pressed ||
//                    gamePad.Buttons.Start == ButtonState.Pressed ||
//                    // Back or Escape exits our game on Xbox 360 and Windows
//                    keyboard.IsKeyDown(Keys.Escape) ||
//                    gamePad.Buttons.Back == ButtonState.Pressed) &&
//                    remSpaceOrStartPressed == false &&
//                    remEscOrBackPressed == false)
//                {
//                    // Quit app.
//                    if (currentMenuItem == 2 ||
//                        keyboard.IsKeyDown(Keys.Escape) ||
//                        gamePad.Buttons.Back == ButtonState.Pressed)
//                    {
//                        this.Exit();
//                    } // if
//                    else
//                    {
//                        // Start game
//                        gameMode = GameMode.Game;
//                        leftPlayerLives = 3;
//                        rightPlayerLives = 3;
//                        leftPaddlePosition = 0.5f;
//                        rightPaddlePosition = 0.5f;
//                        StartNewBall();
//                        // Set multiplayer if it was selected in menu.
//                        // Otherwise the computer controls the left paddle
//                        multiplayer = currentMenuItem == 1;
//                    } // else
//                } // else if
//            } // if
//            else
//            {
//                // Show lives
//                ShowLives();

//                // Ball in center
//                RenderBall();
//                // Render both paddles
//                RenderPaddles();

//                // If game is over, show winner
//                if (gameMode == GameMode.GameOver)
//                {
//                    if (leftPlayerLives == 0)
//                        RenderSprite(menuTexture,
//                            512 - GameBlueWonRect.Width / 2, 300, GameBlueWonRect);
//                    else
//                        RenderSprite(menuTexture,
//                            512 - GameRedWonRect.Width / 2, 300, GameRedWonRect);

//                    // A, Space or Enter returns us to the main menu.
//                    // Esc and Back do return the the menu too, see below.
//                    // Make sure the keys are released again when we enter the main menu.
//                    if ((gamePad.Buttons.A == ButtonState.Pressed ||
//                        keyboard.IsKeyDown(Keys.Space) ||
//                        keyboard.IsKeyDown(Keys.Enter)) &&
//                        remSpaceOrStartPressed == false)
//                        gameMode = GameMode.Menu;
//                } // if

//                // Back and Escape always quits to the main menu
//                if ((gamePad.Buttons.Back == ButtonState.Pressed ||
//                    keyboard.IsKeyDown(Keys.Escape)) &&
//                    remEscOrBackPressed == false)
//                {
//                    gameMode = GameMode.Menu;
//                    StopBall();
//                } // if
//            } // else

//            // Draw everything on screen.
//            DrawSprites();

//            base.Draw(gameTime);
//        } // Draw(gameTime)
//        #endregion

//        #region Start game
//        public static void StartGame()
//        {
//            using (PongGame game = new PongGame())
//            {
//                game.Run();
//            } // using
//        } // StartGame()
//        #endregion

//        #region Unit tests
//#if DEBUG
//        #region Test delegate
//        /// <summary>
//        /// Test delegate helper
//        /// </summary>
//        delegate void TestDelegate();
//        #endregion

//        #region TestPongGame class
//        /// <summary>
//        /// Helper class to test the PongGame
//        /// </summary>
//        class TestPongGame : PongGame
//        {
//            TestDelegate testLoop;
//            public TestPongGame(TestDelegate setTestLoop)
//            {
//                testLoop = setTestLoop;
//            } // TestPongGame(setTestLoop)

//            protected override void Draw(GameTime gameTime)
//            {
//                base.Draw(gameTime);
//                testLoop();
//            } // Draw(gameTime)
//        } // class TestPongGame
//        #endregion

//        #region StartTest
//        static TestPongGame testGame;
//        static void StartTest(TestDelegate testLoop)
//        {
//            testGame = new TestPongGame(testLoop);
//            testGame.Run();
//            testGame.Dispose();
//        } // RunTest(testLoop)
//        #endregion

//        #region TestSounds
//        public static void TestSounds()
//        {
//            StartTest(
//                delegate
//                {
//                    if (testGame.keyboard.IsKeyDown(Keys.Space))
//                        testGame.soundBank.PlayCue("PongBallHit");
//                    if (testGame.keyboard.IsKeyDown(Keys.LeftControl))
//                        testGame.soundBank.PlayCue("PongBallLost");
//                });
//        } // TestSounds()
//        #endregion

//        #region TestMenuSprites
//        public static void TestMenuSprites()
//        {
//            StartTest(
//                delegate
//                {
//                    testGame.RenderSprite(testGame.menuTexture,
//                        new Rectangle(512 - XnaPongLogoRect.Width / 2, 150,
//                        XnaPongLogoRect.Width, XnaPongLogoRect.Height),
//                        XnaPongLogoRect);
//                    testGame.RenderSprite(testGame.menuTexture,
//                        new Rectangle(512 - MenuSingleplayerRect.Width / 2, 300,
//                        MenuSingleplayerRect.Width, MenuSingleplayerRect.Height),
//                        MenuSingleplayerRect);
//                    testGame.RenderSprite(testGame.menuTexture,
//                        new Rectangle(512 - MenuMultiplayerRect.Width / 2, 350,
//                        MenuMultiplayerRect.Width, MenuMultiplayerRect.Height),
//                        MenuMultiplayerRect, Color.Orange);
//                    testGame.RenderSprite(testGame.menuTexture,
//                        new Rectangle(512 - MenuExitRect.Width / 2, 400,
//                        MenuExitRect.Width, MenuExitRect.Height),
//                        MenuExitRect);
//                });
//        } // TestMenuSprites()
//        #endregion

//        #region TestGameSprites
//        public static void TestGameSprites()
//        {
//            StartTest(
//                delegate
//                {
//                    // Show lives
//                    testGame.ShowLives();

//                    // Ball in center
//                    testGame.RenderBall();
//                    // Render both paddles
//                    testGame.RenderPaddles();
//                });
//        } // TestGameSprites()
//        #endregion

//        #region TestSingleplayerGame
//        public static void TestSingleplayerGame()
//        {
//            StartTest(
//                delegate
//                {
//                    // Make sure we are in the game and in singleplayer mode
//                    testGame.gameMode = GameMode.Game;
//                    testGame.multiplayer = false;

//                    // Show lives
//                    testGame.ShowLives();

//                    // Ball in center
//                    testGame.RenderBall();
//                    // Render both paddles
//                    testGame.RenderPaddles();
//                });
//        } // TestSingleplayerGame()
//        #endregion

//        #region TestBallCollisions
//        public static void TestBallCollisions()
//        {
//            StartTest(
//                delegate
//                {
//                    // Make sure we are in the game and in singleplayer mode
//                    testGame.gameMode = GameMode.Game;
//                    testGame.multiplayer = false;
//                    testGame.Window.Title = "Xna Pong - Press 1-5 to start collision tests";

//                    // Start specific collision scene based on the user input.
//                    if (testGame.keyboard.IsKeyDown(Keys.D1))
//                    {
//                        // First test, just collide with screen border
//                        testGame.ballPosition = new Vector2(0.6f, 0.9f);
//                        testGame.ballSpeedVector = new Vector2(1, 1);
//                    } // if
//                    else if (testGame.keyboard.IsKeyDown(Keys.D2))
//                    {
//                        // Second test, straight on collision with right paddle
//                        testGame.ballPosition = new Vector2(0.9f, 0.6f);
//                        testGame.ballSpeedVector = new Vector2(1, 1);
//                        testGame.rightPaddlePosition = 0.7f;
//                    } // if
//                    else if (testGame.keyboard.IsKeyDown(Keys.D3))
//                    {
//                        // Thrid test, straight on collision with left paddle
//                        testGame.ballPosition = new Vector2(0.1f, 0.4f);
//                        testGame.ballSpeedVector = new Vector2(-1, -0.5f);
//                        testGame.leftPaddlePosition = 0.35f;
//                    } // if
//                    else if (testGame.keyboard.IsKeyDown(Keys.D4))
//                    {
//                        // Advanced test to check if we hit the edge of the right paddle
//                        testGame.ballPosition = new Vector2(0.9f, 0.4f);
//                        testGame.ballSpeedVector = new Vector2(1, -0.5f);
//                        testGame.rightPaddlePosition = 0.29f;
//                    } // if
//                    else if (testGame.keyboard.IsKeyDown(Keys.D5))
//                    {
//                        // Advanced test to check if we hit the edge of the right paddle
//                        testGame.ballPosition = new Vector2(0.9f, 0.4f);
//                        testGame.ballSpeedVector = new Vector2(1, -0.5f);
//                        testGame.rightPaddlePosition = 0.42f;
//                    } // if

//                    // Show lives
//                    testGame.ShowLives();

//                    // Ball in center
//                    testGame.RenderBall();
//                    // Render both paddles
//                    testGame.RenderPaddles();
//                });
//        } // TestBallCollisions()
//        #endregion
//#endif
//        #endregion
//    } // class PongGame
//} // namespace XnaPong
